// shallowReactive(浅的劫持，浅的监视，浅的响应数据) 与 reactive(深的)

// 定义一个reactiveHandler处理对象
const reactiveHandler = {
  //  获取属性值
  get(target, prop) {
    const result = Reflect.get(target, prop)
    console.log('拦截了读取数据', prop, result)
    return result
  },
  // 修改属性值或者添加属性
  set(target, prop, value) {
    const result = Reflect.set(target, prop, value)
    console.log('拦截了修改数据或者添加属性', prop, value)
    return result
  },
  // 删除某个属性值
  deleteProperty(target, prop) {
    const result = Reflect.defineProperty(target, prop)
    cconsole.log('拦截了删除数据', prop)
    return result
  }
}
// 定义一个shallowReactive，传入一个目标对象
function shallowReactive(target) {
  // 判断当前的目标对象是不是object类型(对象/数组)
  if (target && typeof target === 'object') {
    return new Proxy(target, reactiveHandler)
  }
  // 如果传入的数据是基本数据类型，那么就直接返回
  return target
}

// 定义一个reactive函数，传入目标对象
function reactive(target) {
  // 判断当前的目标对象是不是object类型(对象/数组)
  if (target && typeof target === 'object') {
    // 判断当前的数据是不是数组
    if (Array.isArray(target)) {
      // 数组的数据要进行遍历操作
      target.forEach((item, index) => {
        target[index] = reactive(item)
      })
    } else {
      // 在判断当前的数据是不是对象
      // 对象的数据也要进行遍历的操作
      Object.keys(target).forEach((key) => {
        target[key] = reactive(target[key])
      })
    }

    return new Proxy(target, reactiveHandler)
  }
  // 如果传入的数据是基本数据类型，那么就直接返回
  return target
}

// ------------------
// 定义了一个readonlyHander处理器
const readonlyHander = {
  get(target, prop) {
    const result = Reflect.get(target, prop)
    console.log('拦截到了读取数据了', prop, result)
    return result
  },
  set(target, prop, value) {
    console.warn('只能读取数据，不能修改数据或者添加数据')
    return true
  },
  deleteProperty(target, prop) {
    console.log('只能读取数据，不能删除数据')
    return true
  }
}

// 定义一个shallowReadonly函数
function shallowReadonly(target) {
  // 需要判断当前的数据是不是对象
  if (target && typeof target === 'object') {
    return new Proxy(target, readonlyHander)
  }
  return target
}

// 定义一个readonly函数
function readonly() {
  // 需要判断当前的数据是不是对象
  if (target && typeof target === 'object') {
    // 判断是不是数组
    if (Array.isArray(target)) {
    } else {
      // 判断是不是对象
    }
    return new Proxy(target, readonlyHander)
  }
  // 如果不是对象或者数据，那么直接返回
  return target
}
